import { useState } from "react";
import type { ChatMessage } from "../types/chat";
import type { CreateSessionRequestType } from "../services/chat/createSession";
import TokenManager from "../utils/TokenManager";
import { getDeviceId } from "../utils/deviceInfo";
import { StreamEvent } from "../enum/index";

/**
 * 聊天消息处理Hook
 *
 * 提供统一的消息发送和流式响应处理逻辑，可在登录前后使用
 */
export function useChatMessage() {
  const [isLoading, setIsLoading] = useState<boolean>(false);
  const [isStreaming, setIsStreaming] = useState<boolean>(false);

  /**
   * 发送文本消息并处理流式响应
   * @param params 请求参数
   * @param onChunk 处理流式响应的回调函数
   * @returns 最终的AI响应消息
   */
  const sendTextMessage = async (
    params: CreateSessionRequestType,
    onChunk?: (message: ChatMessage, done: boolean, thinking?: string) => void
  ): Promise<ChatMessage> => {
    try {
      // 请求URL
      const url = "https://www.beloved.ltd:8089/ai/chat";

      // 输出请求参数，方便调试
      console.log("[useChatMessage] 发送消息请求参数:", {
        sessionId: params.sessionId,
        model: params.model,
        searchNetwork: params.searchNetwork,
        enableDeepThink: params.enableDeepThink,
      });

      // 发起API请求
      const response = await fetch(url, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "X-Device-Id": getDeviceId(),
          Authorization: TokenManager.getToken() || "",
          Accept: "text/event-stream",
        },
        body: JSON.stringify({
          sessionId: params.sessionId,
          content: params.content,
          model: params.model,
          // enableDeepThink: params.enableDeepThink,
          searchNetwork: params.searchNetwork,
        }),
      });

      // 检查响应状态
      if (!response.ok) {
        // 重置加载状态
        setLoadingState(false);
        const errorMessage = `API请求失败: ${response.status}`;

        // 如果提供了回调，发送错误消息
        if (onChunk) {
          const errorResponse: ChatMessage = {
            role: 2,
            content: errorMessage,
          };
          onChunk(errorResponse, true);
        }

        throw new Error(errorMessage);
      }

      // 检查是否支持流式响应
      if (!response.body) {
        // 重置加载状态
        setLoadingState(false);
        const errorMessage = "浏览器不支持流式响应";

        // 如果提供了回调，发送错误消息
        if (onChunk) {
          const errorResponse: ChatMessage = {
            role: 2,
            content: errorMessage,
          };
          onChunk(errorResponse, true);
        }

        throw new Error(errorMessage);
      }

      // 初始化变量
      let currentContent = "";
      let previousContent = ""; // 记录前一个数据块的内容，用于判断是否有更新
      let thinking: string | undefined;
      let sessionId = params.sessionId;
      let chunkCount = 0;

      // 创建响应流读取器
      const reader = response.body.getReader();
      const decoder = new TextDecoder();

      // 用于解析SSE数据
      const dataRegex = /^data:\s*(.+)$/;
      let buffer = "";

      // 处理读取流
      while (true) {
        const { value, done } = await reader.read();

        if (done) {
          console.log(
            `[useChatMessage] 数据流读取完成，最终内容长度: ${currentContent.length}`
          );

          // 通知完成
          if (onChunk) {
            const finalMessage: ChatMessage = {
              role: 1,
              content: currentContent,
              ...(thinking && { thinking }),
              ...(sessionId && { sessionId }),
            };
            onChunk(finalMessage, true, thinking);
          }
          break;
        }

        // 解析数据块
        const chunk = decoder.decode(value, { stream: true });

        // 处理数据
        buffer += chunk;
        const lines = buffer.split("\n");
        buffer = lines.pop() || ""; // 保留不完整的行

        for (const line of lines) {
          if (!line.trim()) continue;

          // 匹配data:前缀的行
          const match = line.match(dataRegex);
          if (!match) continue;

          try {
            const rawData = match[1];
            if (!rawData.trim()) continue;

            const parsedData = JSON.parse(rawData);
            chunkCount++;

            // 处理不同类型的事件
            if (parsedData.event === StreamEvent.DATA) {
              if (parsedData.data) {
                // 检查并记录每个数据块中的sessionId
                if (parsedData.data.sessionId) {
                  const newSessionId = parsedData.data.sessionId;
                  if (sessionId !== newSessionId) {
                    console.log(
                      `[useChatMessage] 数据块 #${chunkCount} 更新sessionId: ${newSessionId} (旧值: ${
                        sessionId || "无"
                      })`
                    );
                    sessionId = newSessionId;
                  }
                }

                // 处理新内容
                if (
                  typeof parsedData.data.content === "string" &&
                  parsedData.data.content
                ) {
                  const newContent = parsedData.data.content;

                  // 检查该内容块是否与前一个相同
                  if (newContent !== previousContent) {
                    console.log(
                      `[useChatMessage] 数据块 #${chunkCount} 包含内容，长度: ${newContent.length}`
                    );
                    // 确定需要追加的内容
                    // 如果previousContent是新内容的子字符串，只追加新增部分
                    if (
                      newContent.startsWith(previousContent) &&
                      previousContent.length > 0
                    ) {
                      // 追加新内容中与previous不重叠的部分
                      const appendContent = newContent.substring(
                        previousContent.length
                      );
                      console.log(
                        `[useChatMessage] 追加内容长度: ${appendContent.length}`
                      );
                      currentContent += appendContent;
                    } else {
                      // 如果之前没有内容或内容结构完全不同，直接追加整个新内容
                      if (currentContent.length === 0) {
                        currentContent = newContent;
                      } else {
                        // 完全不同的内容，直接全部追加（可能会导致内容重复，但确保不会丢失数据）
                        currentContent += newContent;
                        console.log(
                          `[useChatMessage] 检测到内容不连续，完全追加`
                        );
                      }
                    }
                    // 记录此次内容，用于下次比较
                    previousContent = newContent;
                    console.log(
                      `[useChatMessage] 更新后的总内容长度: ${currentContent.length}`
                    );
                  } else {
                    console.log(
                      `[useChatMessage] 数据块 #${chunkCount} 内容与前一块相同，跳过更新`
                    );
                  }
                } else {
                  console.log(
                    `[useChatMessage] 数据块 #${chunkCount} 内容为空或不是字符串，跳过`
                  );
                }

                // 处理thinking字段 - 保持不变
                if (
                  parsedData.data.thinking !== undefined &&
                  parsedData.data.thinking !== thinking
                ) {
                  thinking = parsedData.data.thinking;
                  console.log(
                    `[useChatMessage] 接收到思考内容，长度: ${
                      thinking ? thinking.length : 0
                    }`
                  );
                }

                // 每次接收到新数据后都更新UI，确保sessionId能立即传递给上层组件
                if (onChunk) {
                  const message: ChatMessage = {
                    role: 1,
                    content: currentContent,
                    ...(thinking && { thinking }),
                    ...(sessionId && { sessionId }),
                  };
                  // 确保在收到第一个内容块时立即通知UI更新
                  onChunk(message, false, thinking);
                }
              }
            } else if (parsedData.event === StreamEvent.DONE) {
              console.log(
                `[useChatMessage] 收到DONE事件，总接收数据块: ${chunkCount}，最终内容长度: ${
                  currentContent.length
                }，会话ID: ${sessionId || "无"}`
              );
            }
          } catch (error) {
            console.error("[useChatMessage] 解析数据失败:", error);
          }
        }
      }

      // 返回最终消息
      return {
        role: 1,
        content: currentContent,
        ...(thinking && { thinking }),
        ...(sessionId && { sessionId }),
      };
    } catch (error) {
      console.error("[useChatMessage] 发送消息出错:", error);
      // 确保错误发生时重置加载状态
      setLoadingState(false);

      // 创建错误消息
      const errorMessage: ChatMessage = {
        role: 2,
        content: `发送消息失败: ${
          error instanceof Error ? error.message : "未知错误"
        }`,
      };

      // 如果有回调函数，直接通过回调发送错误消息到UI
      if (onChunk) {
        onChunk(errorMessage, true);
      }

      // 返回错误消息
      return errorMessage;
    }
  };

  /**
   * 处理消息发送的状态更新
   */
  const setLoadingState = (loading: boolean, streaming: boolean = loading) => {
    console.log(
      `[useChatMessage] 设置状态: loading=${loading}, streaming=${streaming}`
    );
    setIsLoading(loading);
    setIsStreaming(streaming);
  };

  return {
    sendTextMessage,
    isLoading,
    isStreaming,
    setLoadingState,
  };
}
